home *** CD-ROM | disk | FTP | other *** search
/ Aminet 44 / Aminet 44 (2001)(GTI - Schatztruhe)[!][Aug 2001].iso / Aminet / dev / gui / gtlayout.lha / Source / LTP_Storage.c < prev    next >
C/C++ Source or Header  |  1999-01-03  |  5KB  |  328 lines
  1. /*
  2. **    GadTools layout toolkit
  3. **
  4. **    Copyright © 1993-1999 by Olaf `Olsen' Barthel
  5. **        Freely distributable.
  6. **
  7. **    :ts=4
  8. */
  9.  
  10. #ifndef _GTLAYOUT_GLOBAL_H
  11. #include "gtlayout_global.h"
  12. #endif
  13.  
  14. #include "Assert.h"
  15.  
  16. VOID
  17. LTP_GetStorage(ObjectNode *Node)
  18. {
  19.     if(Node->Storage)
  20.     {
  21.         LONG    Number = 0;
  22.         STRPTR    String = NULL;
  23.  
  24.         switch(Node->StorageType)
  25.         {
  26.             case STORAGE_BYTE:
  27.  
  28.                 Number = *(BYTE *)Node->Storage;
  29.                 break;
  30.  
  31.             case STORAGE_UBYTE:
  32.  
  33.                 Number = *(UBYTE *)Node->Storage;
  34.                 break;
  35.  
  36.             case STORAGE_WORD:
  37.  
  38.                 Number = *(WORD *)Node->Storage;
  39.                 break;
  40.  
  41.             case STORAGE_UWORD:
  42.  
  43.                 Number = *(UWORD *)Node->Storage;
  44.                 break;
  45.  
  46.             case STORAGE_LONG:
  47.  
  48.                 Number = *(LONG *)Node->Storage;
  49.                 break;
  50.  
  51.             case STORAGE_ULONG:
  52.  
  53.                 Number = *(ULONG *)Node->Storage;
  54.                 break;
  55.  
  56.             case STORAGE_STRPTR:
  57.  
  58.                 String = Node->Storage;
  59.                 break;
  60.         }
  61.  
  62.         switch(Node->Type)
  63.         {
  64.             case POPUP_KIND:
  65.             case TAB_KIND:
  66.             case GAUGE_KIND:
  67.             case TAPEDECK_KIND:
  68.             case LEVEL_KIND:
  69.  
  70.             case CHECKBOX_KIND:
  71.             case LISTVIEW_KIND:
  72.             case MX_KIND:
  73.             case CYCLE_KIND:
  74.             case PALETTE_KIND:
  75.             case SLIDER_KIND:
  76.             case SCROLLER_KIND:
  77.  
  78.                 Node->Current = Number;
  79.                 break;
  80.  
  81.             case PASSWORD_KIND:
  82.             case STRING_KIND:
  83.             case FRACTION_KIND:
  84.  
  85.                 Node->Special.String.String = String;
  86.                 break;
  87.  
  88.             case INTEGER_KIND:
  89.  
  90.                 Node->Special.Integer.Number = Number;
  91.                 break;
  92.  
  93.             #ifdef DO_TEXTEDIT_KIND
  94.             {
  95.                 case TEXTEDIT_KIND:
  96.  
  97.                     Node->Special.TextEdit.String = String;
  98.                     break;
  99.             }
  100.             #endif    /* DO_TEXTEDIT_KIND */
  101.         }
  102.     }
  103. }
  104.  
  105.  
  106. /*****************************************************************************/
  107.  
  108.  
  109. VOID
  110. LTP_PutStorage(ObjectNode *Node)
  111. {
  112.     if(Node->Storage)
  113.     {
  114.         LONG    Number = 0;
  115.         STRPTR    String = NULL;
  116.  
  117.         switch(Node->Type)
  118.         {
  119.             case POPUP_KIND:
  120.             case TAB_KIND:
  121.             case GAUGE_KIND:
  122.             case TAPEDECK_KIND:
  123.             case LEVEL_KIND:
  124.  
  125.             case CHECKBOX_KIND:
  126.             case LISTVIEW_KIND:
  127.             case MX_KIND:
  128.             case CYCLE_KIND:
  129.             case PALETTE_KIND:
  130.             case SLIDER_KIND:
  131.             case SCROLLER_KIND:
  132.  
  133.                 Number = Node->Current;
  134.                 break;
  135.  
  136.             #ifdef DO_PASSWORD_KIND
  137.             {
  138.                 case PASSWORD_KIND:
  139.  
  140.                     String = Node->Special.String.RealString;
  141.                     break;
  142.             }
  143.             #endif
  144.  
  145.             #ifdef DO_TEXTEDIT_KIND
  146.             {
  147.                 case TEXTEDIT_KIND:
  148.  
  149.                     if(Node->Host != NULL)
  150.                     {
  151.                         GetAttr(STRINGA_Buffer,Node->Host,(ULONG *)&String);
  152.                     }
  153.                     else
  154.                     {
  155.                         String = Node->Special.TextEdit.String;
  156.                     }
  157.  
  158.                     break;
  159.             }
  160.             #endif /* DO_TEXTEDIT_KIND */
  161.  
  162.             case STRING_KIND:
  163.             case FRACTION_KIND:
  164.  
  165.                 if(Node->Host)
  166.                     String = ((struct StringInfo *)Node->Host->SpecialInfo)->Buffer;
  167.                 else
  168.                     String = Node->Special.String.String;
  169.  
  170.                 if(Node->Type == FRACTION_KIND)
  171.                 {
  172.                     LTP_CopyFraction(Node->Special.String.RealString,String);
  173.                     String = Node->Special.String.RealString;
  174.                 }
  175.  
  176.                 break;
  177.  
  178.             case INTEGER_KIND:
  179.  
  180.                 if(Node->Host)
  181.                     Number = ((struct StringInfo *)Node->Host->SpecialInfo)->LongInt;
  182.                 else
  183.                     Number = Node->Special.Integer.Number;
  184.  
  185.                 break;
  186.         }
  187.  
  188.         switch(Node->StorageType)
  189.         {
  190.             case STORAGE_BYTE:
  191.  
  192.                 if(!String)
  193.                     *(BYTE *)Node->Storage = (BYTE)Number;
  194.  
  195.                 break;
  196.  
  197.             case STORAGE_UBYTE:
  198.  
  199.                 if(!String)
  200.                     *(UBYTE *)Node->Storage = (UBYTE)Number;
  201.  
  202.                 break;
  203.  
  204.             case STORAGE_WORD:
  205.  
  206.                 if(!String)
  207.                     *(WORD *)Node->Storage = (WORD)Number;
  208.  
  209.                 break;
  210.  
  211.             case STORAGE_UWORD:
  212.  
  213.                 if(!String)
  214.                     *(UWORD *)Node->Storage = (UWORD)Number;
  215.  
  216.                 break;
  217.  
  218.             case STORAGE_LONG:
  219.  
  220.                 if(!String)
  221.                     *(LONG *)Node->Storage = (LONG)Number;
  222.  
  223.                 break;
  224.  
  225.             case STORAGE_ULONG:
  226.  
  227.                 if(!String)
  228.                     *(ULONG *)Node->Storage = (ULONG)Number;
  229.  
  230.                 break;
  231.  
  232.             case STORAGE_STRPTR:
  233.  
  234.                 if(String)
  235.                     strcpy(Node->Storage,String);
  236.  
  237.                 break;
  238.         }
  239.     }
  240. }
  241.  
  242.  
  243. /*****************************************************************************/
  244.  
  245.  
  246. VOID
  247. LTP_CopyFraction(STRPTR To,STRPTR From)
  248. {
  249.     UBYTE DecimalPoint,c;
  250.     BOOL GotPoint;
  251.     STRPTR Orig;
  252.  
  253.         /* If there is nothing to copy from, pretend it's an empty string. */
  254.  
  255.     if(From == NULL)
  256.         From = "";
  257.  
  258.     DecimalPoint = LTP_DecimalPoint[0];
  259.  
  260.         /* Skip leading junk. */
  261.  
  262.     while(*From != '.' && (*From < '0' || *From > '9') && *From != '\0' && *From != DecimalPoint)
  263.         From++;
  264.  
  265.         /* Skip extraenous zeroes. */
  266.  
  267.     while(From[0] == '0')
  268.         From++;
  269.  
  270.     Orig = To;
  271.  
  272.         /* If the first character is just a decimal point, add a zero
  273.          * in front of it.
  274.          */
  275.  
  276.     if(*From == '.' || *From == DecimalPoint)
  277.         *To++ = '0';
  278.  
  279.     GotPoint = FALSE;
  280.  
  281.         /* Now copy and convert the number. */
  282.  
  283.     while(c = *From++)
  284.     {
  285.         if(c == DecimalPoint || c == '.')
  286.         {
  287.             if(!GotPoint)
  288.             {
  289.                 *To++ = '.';
  290.  
  291.                 GotPoint = TRUE;
  292.             }
  293.         }
  294.         else
  295.         {
  296.             if(c >= '0' && c <= '9')
  297.                 *To++ = c;
  298.         }
  299.     }
  300.  
  301.         /* If the string would remain blank,
  302.          * use a zero.
  303.          */
  304.  
  305.     if(Orig == To)
  306.         *To++ = '0';
  307.  
  308.         /* If we didn't get a decimal point, add one. */
  309.  
  310.     if(!GotPoint)
  311.     {
  312.         *To++ = '.';
  313.         *To++ = '0';
  314.     }
  315.  
  316.         /* Strip trailing zeroes if they follow the decimal point. */
  317.  
  318.     if(GotPoint)
  319.     {
  320.         while(To > Orig && To[-1] == '0' && To[-2] == '0')
  321.             To--;
  322.     }
  323.  
  324.         /* Terminate the string. */
  325.  
  326.     *To = '\0';
  327. }
  328.